home *** CD-ROM | disk | FTP | other *** search
/ Aminet 49 / Aminet 49 (2002)(GTI - Schatztruhe)[!][Jun 2002].iso / Aminet / util / wb / ProcessIcon.lha / Source / ProcessIcon.c
C/C++ Source or Header  |  2002-03-04  |  29KB  |  747 lines
  1. #define NAME     "ProcessIcon"
  2. #define REVISION "21"
  3.  
  4. /* Programmheader
  5.  
  6.         Name:           ProcessIcon
  7.         Author:         SDI
  8.         Distribution:   PD
  9.         Description:    processes .info files
  10.         Compileropts:   -
  11.         Linkeropts:     -l amiga
  12.  
  13.  1.0   01.93.97 : first version
  14.  1.1   03.03.97 : options KILLSTACKSIZE, KILLDEFTOOL, VIEW
  15.  1.2   05.03.97 : added SIT and CIT options
  16.  1.3   29.03.97 : not existing TO produces icon
  17.  1.4   13.06.97 : lots of changes, renamed from CopyIconImage
  18.  1.5   14.06.97 : added more data to VIEW option
  19.  1.6   01.07.97 : fixed problem with DrawerData
  20.  1.7   09.11.97 : added UNSNAP function
  21.  1.8   05.02.98 : IMGSRC became REFICON, added CII instead of autocopy
  22.  1.9   01.09.98 : better VIEW output
  23.  1.10  08.05.99 : added REMAP option
  24.  1.11  21.09.99 : KTT removes entry totally
  25.  1.12  11.10.99 : add SSS option
  26.  1.13  05.11.99 : added NewIcon support
  27.  1.14  09.11.99 : added OS3.5 support, better source, removed global variables,
  28.     program got multi-reentrant
  29.  1.15  10.11.99 : little bug fix
  30.  1.16  15.11.99 : added MAKECI
  31.  1.17  21.11.99 : bug-fix
  32.  1.18  27.11.99 : added SHOWTYPE
  33.  1.19  29.11.99 : Fixed II2CI, SHOWTYPE
  34.  1.20  25.01.02 : fiex MAKECI for NewIcons
  35.  1.21  02.02.02 : added ROM2CI option
  36. */
  37.  
  38. #include <proto/dos.h>
  39. #include <proto/icon.h>
  40. #include <proto/exec.h>
  41. #include <proto/graphics.h>
  42. #include <exec/memory.h>
  43. #include <workbench/icon.h>
  44. #define SDI_TO_ANSI
  45. #include "SDI_ASM_STD_protos.h"
  46. #include "SDI_defines.h"
  47.  
  48. #define PARAM (STRPTR)  "ICON/A,REFICON,VIEW/S,OPT=OPTIMIZE/S,"         \
  49.                         "US=UNSNAP/S,REMAP/S,SHOWTYPE/S,"               \
  50.                         "NI2CI/S,MWB2CI/S,ROM2CI/S,II2CI/S,MAKECI/S,"   \
  51.                         "SBP=SETBITPLANES/N,SDT=SETDEFTOOL,"            \
  52.                         "SIT=SETICONTYPE,SSS=SETSTACKSIZE/N,"           \
  53.                         "ST1=SETTRANSPARENT1/N,ST2=SETTRANSPARENT2/N,"    \
  54.                         "SXP=SETXPOS/N,SYP=SETYPOS/N,"                  \
  55.                         "KCI=KILLCOLORICON/S,"                          \
  56.                         "KDD=KILLDRAWERDATA/S,KDT=KILLDEFTOOL/S,"       \
  57.                         "KII=KILLICONIMAGE/S,KNI=KILLNEWICON/S,"        \
  58.                         "KSS=KILLSTACKSIZE/S,KTT=KILLTOOLTYPES/S,"      \
  59.                         "CCI=COPYCOLORICON/S,"                          \
  60.                         "CDD=COPYDRAWERDATA/S,CDT=COPYDEFTOOL/S,"       \
  61.                         "CII=COPYICONIMAGE/S,CIT=COPYICONTYPE/S,"       \
  62.                         "CNI=COPYNEWICON/S,CSS=COPYSTACKSIZE/S,"        \
  63.                         "CTT=COPYTOOLTYPES/S"
  64. struct Args {
  65.     STRPTR      icon;
  66.     STRPTR      reficon;
  67.     ULONG       view;
  68.     ULONG       optimize;
  69.     ULONG       unsnap;
  70.     ULONG       remap;
  71.     ULONG    showtype;
  72.     ULONG       ni2ci;
  73.     ULONG       mwb2ci;
  74.     ULONG       rom2ci;
  75.     ULONG       ii2ci;
  76.     ULONG       makeci;
  77.     ULONG *     setbitplanes;
  78.     STRPTR      setdeftool;
  79.     STRPTR      seticontype;
  80.     ULONG *     setstacksize;
  81.     LONG *    settransparent1;
  82.     LONG *      settransparent2;
  83.     ULONG *     setxpos;
  84.     ULONG *     setypos;
  85.     ULONG       killcoloricon;
  86.     ULONG       killdrawerdata;
  87.     ULONG       killdeftool;
  88.     ULONG       killiconimage;
  89.     ULONG       killnewicon;
  90.     ULONG       killstacksize;
  91.     ULONG       killtooltypes;
  92.     ULONG       copycoloricon;
  93.     ULONG       copydrawerdata;
  94.     ULONG       copydeftool;
  95.     ULONG       copyiconimage;
  96.     ULONG       copyicontype;
  97.     ULONG       copynewicon;
  98.     ULONG       copystacksize;
  99.     ULONG       copytooltypes;
  100. };
  101.  
  102. const STRPTR IconTypeRecog[] = {0, "Disk", "Drawer", "Tool", "Project", "Garbage", "Device", "Kick", "AppIcon"};
  103. const UBYTE NewIconTXT[] = "*** DON'T EDIT THE FOLLOWING LINES!! ***";
  104. const UWORD KIIData[] = {0xF000,0xF000,0xF000,0xF000};
  105. const struct Image KIIImage = {0, 0, 4, 4, 1, (UWORD *) &KIIData, 1, 0, 0};
  106. const UBYTE MagicWBPalette[8 * 3] = {
  107.   0x96,0x96,0x96, 0x00,0x00,0x00, 0xFF,0xFF,0xFF, 0x3D,0x65,0xA2,
  108.   0x79,0x79,0x79, 0xAE,0xAE,0xAE, 0xAA,0x92,0x7D, 0xFF,0xAA,0x96
  109. };
  110. const UBYTE Default8Palette[8 * 3] = {
  111.   0xAA,0xAA,0xAA, 0x00,0x00,0x00, 0xFF,0xFF,0xFF, 0x65,0x8A,0xBA,
  112.   0xEF,0x45,0x45, 0x55,0xDF,0x55, 0x00,0x45,0xDF, 0xEF,0x9A,0x00
  113. };
  114. const UBYTE RomIconsPalette[16*3] = {
  115.   0x95,0x95,0x95, 0x00,0x00,0x00, 0xFF,0xFF,0xFF, 0x3B,0x67,0xA2,
  116.   0x7B,0x7B,0x7B, 0xAF,0xAF,0xAF, 0xAA,0x90,0x7C, 0xFF,0xA9,0x97,
  117.   0x00,0x00,0xFF, 0x32,0x32,0x32, 0x60,0x80,0x60, 0xE2,0xD1,0x77,
  118.   0xFF,0xD4,0xCB, 0x7A,0x60,0x48, 0xD2,0xD2,0xD2, 0xE5,0x5D,0x5D
  119. };
  120.  
  121. static void RemapImage(struct Image *im)
  122. {
  123.   ULONG w, i, j, k, d;
  124.   UWORD *ptr;
  125.  
  126.   w = (im->Width+15)>>4; /* divide by 16 */
  127.   ptr = im->ImageData;
  128.  
  129.   if(im->Depth == 1)
  130.   {
  131.     for(i = 0; i < im->Height; ++i)
  132.     {
  133.       for(j = 0; j < w; ++j)
  134.         ptr[i*w + j] ^= 0xFFFF;
  135.       if((k = (w<<4) - im->Width))
  136.       {
  137.         /* clear last unused bits */
  138.         ptr[i*w + j - 1] &= (0xFFFF >> k) << k;
  139.       }
  140.     }
  141.   }
  142.   else
  143.   {
  144.     for(i = 0; i < im->Height; ++i)
  145.     {
  146.       for(j = 0; j < w; ++j)
  147.       {
  148.         k = ptr[i*w + j] ^ ptr[(im->Height + i)*w + j];
  149.         for(d = 2; d < im->Depth; ++d)
  150.           k &= (~ptr[(im->Height*d +i)*w + j]);
  151.         ptr[i*w + j] ^= k;
  152.         ptr[(im->Height + i)*w + j] ^= k;
  153.       }
  154.       if((k = (w<<4) - im->Width))
  155.       {
  156.         /* clear last unused bits */
  157.         ptr[i*w + j - 1] &= (0xFFFF >> k) << k;
  158.         ptr[(im->Height + i)*w + j - 1] &= (0xFFFF >> k) << k;
  159.       }
  160.     }
  161.   }
  162. }
  163.  
  164. #define TESTGROUP(a, b, c)      if((a && (b || c)) || (b && c)) ++argerr
  165.  
  166. #define TYPE_STANDARD   0
  167. #define TYPE_NEWICON    1
  168. #define TYPE_NEWICON35  2
  169. #define TYPE_OS35       3
  170. #define TYPE_BOTHCOLOR  4
  171.  
  172. ULONG dowork(struct Args *args, struct Library *IconBase, ULONG os35mode)
  173. {
  174.   ULONG ret = RETURN_FAIL, s;
  175.   struct DiskObject *dobj;
  176.  
  177.   if((dobj = (os35mode ? GetIconTags(args->icon,
  178.   ICONGETA_FailIfUnavailable, FALSE, ICONGETA_GetPaletteMappedIcon, FALSE, TAG_DONE) :
  179.   GetDiskObjectNew(args->icon))))
  180.   {
  181.     struct DiskObject *dobjdrw; 
  182.     if((dobjdrw = GetDefDiskObject(WBDRAWER)))
  183.     {
  184.       struct DiskObject *dobjsrc = 0;
  185.  
  186.       if(!args->reficon || (dobjsrc = (os35mode ?
  187.       GetIconTags(args->reficon, ICONGETA_GetPaletteMappedIcon, FALSE, TAG_DONE) : GetDiskObject(args->reficon))))
  188.       {
  189.         STRPTR *tooltypes;
  190.         UBYTE *imageBuffer[2] = {0, 0};
  191.         
  192.         if((tooltypes = (STRPTR *) AllocVec(1000*sizeof(STRPTR), MEMF_CLEAR)))
  193.         {
  194.           ULONG type = TYPE_STANDARD;
  195.           STRPTR *tt, t, t2;
  196.  
  197.           if((tt = (STRPTR *) dobj->do_ToolTypes))
  198.           {
  199.             while(*tt)
  200.             {
  201.               if((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT))
  202.                 type = TYPE_NEWICON;
  203.               ++tt;
  204.             }
  205.           }
  206.  
  207.           if(os35mode)
  208.           {
  209.             LONG p = 0, n = 0;
  210.           
  211.             IconControl(dobj, ICONCTRLA_IsPaletteMapped, &p, ICONCTRLA_IsNewIcon, &n, TAG_DONE);
  212.             if(p) type = TYPE_OS35;
  213.             if(n) type = TYPE_NEWICON35;
  214.             if(p && n) type = TYPE_BOTHCOLOR;
  215.           }
  216.  
  217.       if(args->makeci)
  218.       {
  219.         switch(type)
  220.         {
  221.         case TYPE_STANDARD: args->ii2ci = 1; break;
  222.         case TYPE_NEWICON: case TYPE_NEWICON35: args->ni2ci = 1; break;
  223.         case TYPE_BOTHCOLOR: args->killnewicon = 1; break;
  224.         }
  225.       }
  226.  
  227.       if(args->showtype)
  228.       {
  229.             switch(type)
  230.             {
  231.               case TYPE_BOTHCOLOR: t = "OS3.5 + NewIcon"; break;
  232.               case TYPE_NEWICON: case TYPE_NEWICON35: t = "NewIcon"; break;
  233.               case TYPE_OS35: t = "OS3.5 Icon"; break;
  234.               default: t = "Standard"; break;
  235.             }
  236.             Printf("%-15s - %s\n", t, args->icon);
  237.             ret = RETURN_OK;
  238.       }
  239.           else if(args->view)
  240.           {
  241.             switch(type)
  242.             {
  243.               case TYPE_BOTHCOLOR: t = "OS3.5 + NewIcon"; break;
  244.               case TYPE_NEWICON: case TYPE_NEWICON35: t = "NewIcon"; break;
  245.               case TYPE_OS35: t = "OS3.5 Icon"; break;
  246.               default: t = "Standard"; break;
  247.             }
  248.  
  249.             if(type == TYPE_NEWICON)
  250.             {
  251.               t2 = "YES, NEWICON";
  252.  
  253.               if((**dobj->do_ToolTypes == ' ') && *(dobj->do_ToolTypes[1]) &&
  254.               !strcmp(dobj->do_ToolTypes[1], (STRPTR) NewIconTXT))
  255.                 t2 = "YES - EMPTY, NEWICON";
  256.             }
  257.             else if(type == TYPE_NEWICON35 || type == TYPE_BOTHCOLOR)
  258.             {
  259.               t2 = "YES, NEWICON";
  260.  
  261.               if(!(*dobj->do_ToolTypes))
  262.                 t2 = "YES - EMPTY, NEWICON";
  263.             }
  264.             else if(dobj->do_ToolTypes)
  265.             {
  266.               if(!(*dobj->do_ToolTypes))
  267.                 t2 = "YES - EMPTY";
  268.               else
  269.                 t2 = "YES";
  270.             }
  271.             else
  272.               t2 = "NO";
  273.  
  274.             Printf("Name: %s\nType: %s\n  SS: %ld\n  IT: %s\n  BP: %ld,%ld\n  SZ: ",
  275.               args->icon, t, dobj->do_StackSize, IconTypeRecog[dobj->do_Type],
  276.               ((struct Image *)dobj->do_Gadget.GadgetRender)->Depth,
  277.               (dobj->do_Gadget.SelectRender ?
  278.               ((struct Image *)dobj->do_Gadget.SelectRender)->Depth : 0));
  279.             Printf(dobj->do_CurrentX == NO_ICON_POSITION ? "NOPOS" : "x=%3ld",
  280.               dobj->do_CurrentX);
  281.             Printf(dobj->do_CurrentY == NO_ICON_POSITION ? ", NOPOS" : ", y=%3ld",
  282.               dobj->do_CurrentY);
  283.             Printf(", w=%3ld, h=%3ld\n  DT: (%s) %s\n",
  284.               dobj->do_Gadget.Width, dobj->do_Gadget.Height,
  285.               (dobj->do_DefaultTool ? "YES" : "NO"), dobj->do_DefaultTool);
  286.             
  287.             if(type == TYPE_OS35 || type == TYPE_BOTHCOLOR)
  288.             {
  289.           LONG t1 = -1, t2 = -1, fr = 0, w = 0, h = 0, i2, s1, s2;
  290.  
  291.               IconControl(dobj, ICONCTRLA_GetTransparentColor1, &t1, TAG_DONE);
  292.               IconControl(dobj, ICONCTRLA_GetPaletteSize1, &s1, TAG_DONE);
  293.               IconControl(dobj, ICONCTRLA_GetPaletteSize2, &s2, TAG_DONE);
  294.               IconControl(dobj, ICONCTRLA_GetTransparentColor2, &t2, TAG_DONE);
  295.               IconControl(dobj, ICONCTRLA_GetImageData2, &i2, TAG_DONE);
  296.               IconControl(dobj, ICONCTRLA_GetFrameless, &fr, TAG_DONE);
  297.               IconControl(dobj, ICONCTRLA_GetWidth, &w, TAG_DONE);
  298.               IconControl(dobj, ICONCTRLA_GetHeight, &h, TAG_DONE);
  299.  
  300.           Printf("  CI -Width      : %3ld\n  CI -Height     : %3ld\n"
  301.           "  CI -Borderless : %s\n  CI -NumImages  : %3ld\n  CI1-Transparent: ",
  302.           w, h, fr ? "YES" : "NO",i2 ? 2 : 1);
  303.           
  304.           Printf(t1 == -1 ? "NO" : "%3ld", t1);
  305.           Printf("\n  CI1-NumColors  : %3ld\n", s1);
  306.           if(i2)
  307.           {
  308.                 Printf("  CI2-Transparent: ");
  309.             Printf(t2 == -1 ? "NO" : "%3ld", t2);
  310.                 Printf("\n  CI2-NumColors  : %3ld\n", s2);
  311.               }
  312.             }
  313.  
  314.             Printf("  TT: (%s)\n", t2);
  315.  
  316.             if((tt = (STRPTR *) dobj->do_ToolTypes))
  317.             {
  318.               while(*tt)
  319.               {
  320.                 if((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT))
  321.                   break;
  322.                 else
  323.                   Printf("  %s\n", *(tt++));
  324.               }
  325.             }
  326.             ret = RETURN_OK;
  327.  
  328. #ifdef DEBUG
  329.   Printf("NextGadget:   $%08lx\n", dobj->do_Gadget.NextGadget);
  330.   Printf("LeftEdge:     %4ld\n", dobj->do_Gadget.LeftEdge);
  331.   Printf("TopEdge:      %4ld\n", dobj->do_Gadget.TopEdge);
  332.   Printf("Width:        %4ld\n", dobj->do_Gadget.Width);
  333.   Printf("Height:       %4ld\n", dobj->do_Gadget.Height);
  334.   Printf("Flags:        $%04lx\n", dobj->do_Gadget.Flags);
  335.   Printf("Activation:   $%04lx\n", dobj->do_Gadget.Activation);
  336.   Printf("GadgetType:   %4ld\n", dobj->do_Gadget.GadgetType);
  337.   Printf("GadgetRender: $%08lx\n", dobj->do_Gadget.GadgetRender);
  338.   Printf("SelectRender: $%08lx\n", dobj->do_Gadget.SelectRender);
  339.   Printf("GadgetText:   $%08lx\n", dobj->do_Gadget.GadgetText);
  340.   Printf("MutualExclude:%4ld\n", dobj->do_Gadget.MutualExclude);
  341.   Printf("SpecialInfo:  $%08lx\n", dobj->do_Gadget.SpecialInfo);
  342.   Printf("GadgetID:     %4ld\n", dobj->do_Gadget.GadgetID);
  343.   Printf("UserData:     $%08lx\n", dobj->do_Gadget.UserData);
  344.   if(dobj->do_Gadget.Flags & GFLG_GADGIMAGE)
  345.   {
  346.     struct Image *i;
  347.     
  348.     i = (struct Image *) dobj->do_Gadget.GadgetRender;
  349.     Printf("LeftEdge:     %4ld\n", i->LeftEdge);
  350.     Printf("TopEdge:      %4ld\n", i->TopEdge);
  351.     Printf("Width:        %4ld\n", i->Width);
  352.     Printf("Height:       %4ld\n", i->Height);
  353.     Printf("Depth:        %4ld\n", i->Depth);
  354.     Printf("ImageData:    $%08lx\n", i->ImageData);
  355.     Printf("PlanePick:    %2ld\n", i->PlanePick);
  356.     Printf("PlaneOnOff:   %2ld\n", i->PlaneOnOff);
  357.     Printf("NextImage:    $%08lx\n", i->NextImage);
  358.   }
  359. #endif
  360.           }
  361.           else
  362.           {
  363.             if(args->copyiconimage)
  364.             {
  365.               if(dobj->do_CurrentX != NO_ICON_POSITION && dobj->do_CurrentY != NO_ICON_POSITION)
  366.               {
  367.                 dobj->do_CurrentX += (dobj->do_Gadget.Width>>1) - (dobjsrc->do_Gadget.Width>>1);
  368.                 dobj->do_CurrentY += dobj->do_Gadget.Height - dobjsrc->do_Gadget.Height;
  369.                 /* 'down middle position' of gadget should be same after image copy */
  370.               }
  371.               dobj->do_Gadget = dobjsrc->do_Gadget;       /* copy gadget structures */
  372.             }
  373.  
  374.             if(args->copytooltypes || args->copynewicon)
  375.             {
  376.               s = 0;
  377.               if((tt = (STRPTR *) (args->copytooltypes ? dobjsrc : dobj)->do_ToolTypes))
  378.               {
  379.                  while(*tt && !((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT)))
  380.                   tooltypes[s++] = *(tt++);
  381.               }
  382.               if((tt = (STRPTR *) (args->copynewicon ? dobjsrc : dobj)->do_ToolTypes))
  383.               {
  384.                 while(*tt && !((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT)))
  385.                   ++tt;
  386.                 while(*tt)
  387.                   tooltypes[s++] = *(tt++);
  388.               }
  389.               dobj->do_ToolTypes = (char **) (s ? tooltypes : 0);
  390.             }
  391.  
  392.             if(args->seticontype)
  393.             {
  394.               s = 0;
  395.  
  396.               while(++s <= WBAPPICON && stricmp(IconTypeRecog[s], args->seticontype))
  397.                 ;
  398.               if(s <= WBAPPICON)
  399.                 dobj->do_Type = s;
  400.  
  401.               if(!(dobj->do_DrawerData && (dobj->do_Type == WBDISK ||
  402.               dobj->do_Type == WBGARBAGE || dobj->do_Type == WBDRAWER)))
  403.                 dobj->do_DrawerData = dobjdrw->do_DrawerData;
  404.             }
  405.  
  406.             if(args->remap)
  407.             {
  408.               RemapImage((struct Image *) dobj->do_Gadget.GadgetRender);
  409.               if(dobj->do_Gadget.SelectRender)
  410.                 RemapImage((struct Image *) dobj->do_Gadget.SelectRender);
  411.             }
  412.  
  413.             if(args->setbitplanes)
  414.             {
  415.               ((struct Image *) dobj->do_Gadget.GadgetRender)->Depth = *args->setbitplanes;
  416.               if(dobj->do_Gadget.SelectRender)
  417.                 ((struct Image *) dobj->do_Gadget.SelectRender)->Depth = *args->setbitplanes;
  418.             }
  419.  
  420.             if(args->copydeftool)         dobj->do_DefaultTool = dobjsrc->do_DefaultTool;
  421.             if(args->copyicontype)        dobj->do_Type = dobjsrc->do_Type;
  422.             if(args->copystacksize)       dobj->do_StackSize = dobjsrc->do_StackSize;
  423.             if(args->copydrawerdata)      dobj->do_DrawerData = dobjsrc->do_DrawerData;
  424.             if(args->setxpos)             dobj->do_CurrentX = *args->setxpos;
  425.             if(args->setypos)             dobj->do_CurrentY = *args->setypos;
  426.             if(args->setstacksize)        dobj->do_StackSize = *args->setstacksize;
  427.             if(args->setdeftool)          dobj->do_DefaultTool = args->setdeftool;
  428.             if(args->unsnap)              dobj->do_CurrentX = dobj->do_CurrentY = NO_ICON_POSITION;
  429.             if(args->killstacksize)       dobj->do_StackSize = 0;
  430.             if(args->killdeftool)         dobj->do_DefaultTool = 0;
  431.  
  432.             if(args->killdrawerdata)
  433.             {
  434.                     dobj->do_DrawerData = dobjdrw->do_DrawerData;
  435.               if(dobj->do_Type != WBDISK && dobj->do_Type != WBGARBAGE && dobj->do_Type != WBDRAWER)
  436.                 dobj->do_DrawerData = 0;
  437.             }
  438.  
  439.             if(args->killnewicon && (tt = (STRPTR *) dobj->do_ToolTypes))
  440.             {
  441.               while(*tt)
  442.               {
  443.                 if((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT))
  444.                   *tt = 0;
  445.                 else
  446.                   ++tt;
  447.               }
  448.             }
  449.  
  450.             if(args->killtooltypes && (tt = (STRPTR *) dobj->do_ToolTypes))
  451.             {
  452.               s = 0;
  453.               while(*tt && !((**tt == ' ') && tt[1] && !strcmp(tt[1], (STRPTR) NewIconTXT)))
  454.                 ++tt;
  455.               while(*tt)
  456.                 tooltypes[s++] = *(tt++);
  457.               dobj->do_ToolTypes = (char **) (s ? tooltypes : 0);
  458.             }
  459.  
  460.             if(args->copycoloricon)
  461.             {
  462.               LONG t1=-1, t2=-1, s1=0, s2=0, fr=0, w=0, h=0, wo = 0, ho = 0;
  463.               struct ColorRegister *c1=0, *c2=0;
  464.               UBYTE *i1=0, *i2=0;
  465.               UBYTE as=0;
  466.  
  467.               IconControl(dobjsrc, ICONCTRLA_GetTransparentColor1, &t1, TAG_DONE);
  468.               IconControl(dobjsrc, ICONCTRLA_GetTransparentColor2, &t2, TAG_DONE);
  469.               IconControl(dobjsrc, ICONCTRLA_GetPalette1, &c1, TAG_DONE);
  470.               IconControl(dobjsrc, ICONCTRLA_GetPalette2, &c2, TAG_DONE);
  471.               IconControl(dobjsrc, ICONCTRLA_GetPaletteSize1, &s1, TAG_DONE);
  472.               IconControl(dobjsrc, ICONCTRLA_GetPaletteSize2, &s2, TAG_DONE);
  473.               IconControl(dobjsrc, ICONCTRLA_GetImageData1, &i1, TAG_DONE);
  474.               IconControl(dobjsrc, ICONCTRLA_GetImageData2, &i2, TAG_DONE);
  475.               IconControl(dobjsrc, ICONCTRLA_GetFrameless, &fr, TAG_DONE);
  476.               IconControl(dobjsrc, ICONCTRLA_GetAspectRatio, &as, TAG_DONE);
  477.               IconControl(dobjsrc, ICONCTRLA_GetWidth, &w, TAG_DONE);
  478.               IconControl(dobjsrc, ICONCTRLA_GetHeight, &h, TAG_DONE);
  479.  
  480.               if(!IconControl(dobj, ICONCTRLA_GetWidth, &wo, TAG_DONE))
  481.                 wo =dobj->do_Gadget.Width;
  482.               if(!IconControl(dobj, ICONCTRLA_GetHeight, &ho, TAG_DONE))
  483.                 ho = dobj->do_Gadget.Height;
  484.               if(dobj->do_CurrentX != NO_ICON_POSITION && dobj->do_CurrentY != NO_ICON_POSITION)
  485.               {
  486.                 dobj->do_CurrentX += (wo>>1) - (w>>1);
  487.                 dobj->do_CurrentY += ho - h;
  488.                 /* 'down middle position' of gadget should be same after image copy */
  489.               }
  490.  
  491.               IconControl(dobj, ICONCTRLA_SetAspectRatio, as, TAG_DONE);
  492.               IconControl(dobj, ICONCTRLA_SetWidth, w, TAG_DONE);
  493.               IconControl(dobj, ICONCTRLA_SetHeight, h, TAG_DONE);
  494.               IconControl(dobj, ICONCTRLA_SetPaletteSize1, s1, TAG_DONE);
  495.               IconControl(dobj, ICONCTRLA_SetPaletteSize2, s2, TAG_DONE);
  496.               IconControl(dobj, ICONCTRLA_SetPalette1, c1, TAG_DONE);
  497.               IconControl(dobj, ICONCTRLA_SetPalette2, c2, TAG_DONE);
  498.               IconControl(dobj, ICONCTRLA_SetImageData1, i1, TAG_DONE);
  499.               IconControl(dobj, ICONCTRLA_SetImageData2, i2, TAG_DONE);
  500.               IconControl(dobj, ICONCTRLA_SetFrameless, fr, TAG_DONE);
  501.               IconControl(dobj, ICONCTRLA_SetTransparentColor1, t1, TAG_DONE);
  502.               IconControl(dobj, ICONCTRLA_SetTransparentColor2, t2, TAG_DONE);
  503.               type = TYPE_OS35;
  504.             }
  505.  
  506.             if(args->mwb2ci || args->ii2ci || args->rom2ci) /* made from code by Olaf Barthel */
  507.             {
  508.               struct Image *image[2];
  509.               struct GfxBase *GfxBase;
  510.  
  511.               image[0] = (struct Image *)dobj->do_Gadget.GadgetRender;
  512.               image[1] = (struct Image *)dobj->do_Gadget.SelectRender;
  513.  
  514.               if((GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 37)))
  515.               {
  516.                 struct RastPort rp;
  517.                 struct BitMap bm;
  518.                 LONG pixelsPerImage, pageSize, x, y, i, j;
  519.                 UBYTE *p;
  520.                 PLANEPTR plane;
  521.  
  522.                 for(j = 0; j < 2 && image[j]; ++j)
  523.                 {
  524.                   pixelsPerImage = (LONG)image[j]->Width * (LONG)image[j]->Height;
  525.                   if((imageBuffer[j] = AllocVec(pixelsPerImage, MEMF_ANY)))
  526.                   {
  527.             if(args->rom2ci)
  528.             {
  529.                       if(image[j]->Depth > 4)
  530.                         image[j]->Depth = 4;
  531.             }
  532.             else
  533.             {
  534.                       if(image[j]->Depth > 3)
  535.                         image[j]->Depth = 3;
  536.                     }
  537.  
  538.                     InitRastPort(&rp);
  539.                     rp.BitMap = &bm;
  540.  
  541.                     memset(&bm, 0, sizeof(struct BitMap));
  542.                     bm.BytesPerRow = RASSIZE(image[j]->Width,1);
  543.                     bm.Rows        = image[j]->Height;
  544.                     bm.Depth       = image[j]->Depth;
  545.                     pageSize = RASSIZE(image[j]->Width,image[j]->Height);
  546.                     plane = (PLANEPTR)image[j]->ImageData;
  547.  
  548.                     for(i = 0; i < image[j]->Depth; ++i)
  549.                     {
  550.                       bm.Planes[i] = plane;
  551.                       plane += pageSize;
  552.                     }
  553.  
  554.                     p = imageBuffer[j];
  555.                     for(y = 0; y < image[j]->Height ; y++)
  556.                     {
  557.                       for(x = 0; x < image[j]->Width ; x++)
  558.                         (*p++) = ReadPixel(&rp,x,y);
  559.                     }
  560.                   }
  561.                 }
  562.  
  563.         if(args->rom2ci)
  564.           p = (UBYTE *) RomIconsPalette;
  565.         else
  566.           p = (UBYTE *) (args->mwb2ci ? MagicWBPalette : Default8Palette);
  567.  
  568.                 IconControl(dobj, ICONCTRLA_SetWidth, image[0]->Width, ICONCTRLA_SetHeight, image[0]->Height,
  569.                 ICONCTRLA_SetAspectRatio, PACK_ICON_ASPECT_RATIO(1,1), ICONCTRLA_SetImageData1, imageBuffer[0],
  570.                 ICONCTRLA_SetPaletteSize1, 1<<(image[0]->Depth), ICONCTRLA_SetPalette1, p, TAG_DONE);
  571.  
  572.                 if(image[1])
  573.                 {
  574.                   IconControl(dobj, ICONCTRLA_SetImageData2, imageBuffer[1], ICONCTRLA_SetPaletteSize2,
  575.                   1<<(image[1]->Depth), ICONCTRLA_SetPalette2, p, TAG_DONE);
  576.                 }
  577.                 type = TYPE_OS35;
  578.                 CloseLibrary((struct Library *) GfxBase);
  579.               }
  580.             } /* args->mwb2ci || args->ii2ci || args->rom2ci */
  581.  
  582.         if(os35mode)
  583.         {
  584.           if(args->settransparent1) IconControl(dobj, ICONCTRLA_SetTransparentColor1, *args->settransparent1, TAG_DONE);
  585.           if(args->settransparent2) IconControl(dobj, ICONCTRLA_SetTransparentColor2, *args->settransparent2, TAG_DONE);
  586.         }
  587.  
  588.             if(args->killiconimage)
  589.             {
  590.               if(dobj->do_CurrentX != NO_ICON_POSITION && dobj->do_CurrentY != NO_ICON_POSITION
  591.               && type == TYPE_STANDARD)
  592.               {
  593.                 dobj->do_CurrentX += (dobj->do_Gadget.Width>>1) - 2;
  594.                 dobj->do_CurrentY += dobj->do_Gadget.Height - 5;
  595.                 /* 'down middle position' of gadget should be same after image replace */
  596.               }
  597.               dobj->do_Gadget.LeftEdge = dobj->do_Gadget.TopEdge = 50;
  598.               dobj->do_Gadget.Width = dobj->do_Gadget.Height = 4;
  599.               dobj->do_Gadget.Flags = GFLG_GADGIMAGE;
  600.               dobj->do_Gadget.GadgetRender = (APTR) &KIIImage;
  601.               dobj->do_Gadget.SelectRender = 0;
  602.             }
  603.  
  604.             if(args->optimize)
  605.             {
  606.               if(dobj->do_Type != WBDISK && dobj->do_Type != WBPROJECT)
  607.                 dobj->do_DefaultTool = 0;
  608.               if(dobj->do_Type != WBPROJECT && dobj->do_Type != WBTOOL)
  609.                 dobj->do_ToolTypes = 0;
  610.               if(dobj->do_Type != WBDISK && dobj->do_Type != WBGARBAGE && dobj->do_Type != WBDRAWER)
  611.                 dobj->do_DrawerData = 0;
  612.               if(dobj->do_ToolTypes && !(*dobj->do_ToolTypes))
  613.                 dobj->do_ToolTypes = 0;
  614.             }
  615.  
  616.             if(os35mode)
  617.             {
  618.               if(PutIconTags(args->icon, dobj, ICONPUTA_NotifyWorkbench, TRUE, ICONPUTA_PreserveOldIconImages,
  619.               FALSE, args->killnewicon ? ICONPUTA_DropNewIconToolTypes : TAG_IGNORE, TRUE, 
  620.               args->killcoloricon ? ICONPUTA_DropChunkyIconImage : TAG_IGNORE, TRUE,
  621.               args->optimize ? ICONPUTA_OptimizeImageSpace : TAG_IGNORE, TRUE,
  622.               args->killiconimage ? ICONPUTA_DropPlanarIconImage :  TAG_IGNORE, TRUE, TAG_DONE))
  623.                 ret = RETURN_OK;
  624.             }
  625.             else if(PutDiskObject(args->icon, dobj))
  626.               ret = RETURN_OK;
  627.           } /* !args->view */
  628.  
  629.           if(imageBuffer[0])
  630.             FreeVec(imageBuffer[0]);
  631.           if(imageBuffer[1])
  632.             FreeVec(imageBuffer[1]);
  633.           FreeVec(tooltypes);
  634.         } /* allocate tooltype temp array */
  635.         if(dobjsrc)
  636.           FreeDiskObject(dobjsrc);
  637.       } /* open reficon */
  638.       FreeDiskObject(dobjdrw);
  639.     } /* open drawer disk object */
  640.     FreeDiskObject(dobj);
  641.   } /* open DiskObject */
  642.   return ret;
  643. }
  644.  
  645. LONG main(void)
  646. {
  647.   struct RDArgs *rda;
  648.   struct Args args;
  649.   struct Args argse;
  650.   LONG ret = RETURN_FAIL, os35;
  651.  
  652.   memset(&args, 0, sizeof(struct Args));
  653.   if((rda = ReadArgs(PARAM, (LONG *) &args, 0)))
  654.   {
  655.     struct Library *IconBase;
  656.     if((IconBase = OpenLibrary("icon.library", 37)))
  657.     {
  658.       ULONG argerr = 0;
  659.  
  660.       TESTGROUP(0,                args.killcoloricon,   args.copycoloricon);
  661.       TESTGROUP(0,                args.killdrawerdata,  args.copydrawerdata);
  662.       TESTGROUP(args.setdeftool,  args.killdeftool,     args.copydeftool);
  663.       TESTGROUP(0,                args.killiconimage,   args.copyiconimage);
  664.       TESTGROUP(args.seticontype, 0,                    args.copyicontype);
  665.       TESTGROUP(0,                args.killnewicon,     args.copynewicon);
  666.       TESTGROUP(args.setstacksize,args.killstacksize,   args.copystacksize);
  667.       TESTGROUP(0,                args.killtooltypes,   args.copytooltypes);
  668.  
  669.       TESTGROUP(args.ni2ci,       args.ii2ci,           args.mwb2ci);
  670.  
  671.       if((args.makeci || args.rom2ci) && (args.ii2ci || args.mwb2ci || args.ni2ci))
  672.         ++argerr;
  673.  
  674.       if((args.rom2ci && args.makeci))
  675.         ++argerr;
  676.  
  677.       if(args.unsnap && (args.setxpos || args.setypos))
  678.         ++argerr;
  679.  
  680.       if(IconBase->lib_Version < 44 && (args.ni2ci || args.ii2ci || args.killcoloricon || args.copycoloricon
  681.       || args.mwb2ci))
  682.       {
  683.         Printf("You need icon.library V44 or better for the CI options.\n");
  684.        ++argerr;
  685.       }
  686.  
  687.       if((args.ni2ci || args.mwb2ci || args.ii2ci) && (args.killcoloricon || args.copycoloricon))
  688.         ++argerr;
  689.  
  690.       if(args.killnewicon && args.ni2ci)
  691.         ++argerr;
  692.       
  693.       if(!args.reficon && (args.copydrawerdata || args.copydeftool || args.copyiconimage || args.copyicontype ||
  694.       args.copynewicon || args.copystacksize || args.copytooltypes))
  695.         ++argerr;
  696.  
  697.       if(argerr || (args.setbitplanes && args.killiconimage))
  698.         SetIoErr(ERROR_TOO_MANY_ARGS);
  699.       else
  700.       {
  701.         ULONG s;
  702.  
  703.         s = strlen(args.icon);
  704.         if(!strncmp(args.icon+s-5, ".info",5))
  705.           args.icon[s-5] = 0;
  706.         if(args.reficon)
  707.         {
  708.           s = strlen(args.reficon);
  709.           if(!strncmp(args.reficon+s-5, ".info",5))
  710.           args.reficon[s-5] = 0;
  711.         }
  712.  
  713.         os35 = IconBase->lib_Version >= 44 ? 1 : 0;
  714.         if(!(ret = dowork(&args, IconBase, os35)))
  715.         {
  716.           if(!args.view && os35 && args.copynewicon)
  717.           {
  718.             memset(&argse, 0, sizeof(struct Args));
  719.             argse.icon = args.icon;
  720.             argse.reficon = args.reficon;
  721.             argse.copynewicon = 1;
  722.             ret = dowork(&argse, IconBase, 0);
  723.           }
  724.           if(!args.view && !args.showtype && args.ni2ci)
  725.           {
  726.             struct DiskObject *dobj;
  727.  
  728.             if((dobj = GetIconTags(args.icon, TAG_DONE)))
  729.             {
  730.               if(PutIconTags(args.icon, dobj, ICONPUTA_NotifyWorkbench, TRUE,
  731.               ICONPUTA_DropNewIconToolTypes, TRUE, TAG_DONE));
  732.                 ret = RETURN_OK;
  733.               FreeDiskObject(dobj);
  734.             }
  735.           }
  736.         }
  737.       } /* argument checks */
  738.       CloseLibrary(IconBase);
  739.     } /* open icon.library */
  740.     FreeArgs(rda);
  741.   } /* ReadArgs */
  742.   if(ret)
  743.     PrintFault(IoErr(), 0);
  744.   return ret;
  745. }
  746.  
  747.